/* 
 * @(#)PrivilegioBean.java 
 *  
 * Esta clase presenta la informacion de un especimen  
 * 
 * @version 1.0
 * @date 01/11/12 
 * @author Karen Calderón
 *  
 */
package muhnes.sizoo.controlador;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.faces.event.AjaxBehaviorEvent;
import javax.faces.model.SelectItem;
import muhnes.sizoo.dal.AcuaticoDao;
import muhnes.sizoo.dal.AnimalDao;
import muhnes.sizoo.dal.EspecimenDao;
import muhnes.sizoo.dal.FabricaDAO;
import muhnes.sizoo.dal.RecoleccionDao;
import muhnes.sizoo.dal.TerrestreDao;
import muhnes.sizoo.modelo.Acuatico;
import muhnes.sizoo.modelo.Animal;
import muhnes.sizoo.modelo.Especimen;
import muhnes.sizoo.modelo.Internacional;
import muhnes.sizoo.modelo.Nacional;
import muhnes.sizoo.modelo.Recoleccion;
import muhnes.sizoo.modelo.Terrestre;
import muhnes.sizoo.util.TipoEspecimen;
import muhnes.sizoo.util.Transaccion;
import org.apache.commons.lang3.StringUtils;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.event.FlowEvent;
import org.primefaces.model.UploadedFile;

/**
 * Clase que controla la vista de especimenes
 * @author Karen Calderon
 */
@ManagedBean(name = "especimenBean")
@ViewScoped

public class EspecimenBean extends CRUDBean< Especimen, EspecimenDao > 
    implements Serializable{
    
    private Acuatico acuatico;
    private Terrestre terrestre;
    private TipoEspecimen tipoEspecimen;
    private List< SelectItem > itemsEstado;
    private List< SelectItem > itemsDonacion;
    private List< SelectItem > itemsEspecimen;
    private List< SelectItem > listaAnimal;
    private List< SelectItem > listaRecoleccion;
    private List< SelectItem > listaHabitats;
    private String destino;
    private int contador=0;
    private char cargafoto = 'N';
    private UploadedFile file =null;
    UploadedFile[] fotos = new UploadedFile[15];

    /** 
     * Crea una nueva instancia 
     */
    public EspecimenBean() {
        super( Especimen.class );
        vistaProtegida = "especimen";
        contador=0;
        acuatico = new Acuatico();
        terrestre = new Terrestre();      
    }
    
    /**
     * Obtiene un objeto de tipo acuatico
     *  
     */
    public Acuatico getAcuatico() {
        return acuatico;
    }

    /**
     * Asigna un dato de tipo acuatico
     * @param acuatico 
     */
    public void setAcuatico(Acuatico acuatico) {
        this.acuatico = acuatico;
    }
    
    /**
     * Obtiene un objeto de tipo Terrestre
     * @return 
     */
    public Terrestre getTerrestre() {
        return terrestre;
    }

    /**
     * asigna un dato de tipo terrestre
     * @param terrestre 
     */
    public void setTerrestre(Terrestre terrestre) {
        this.terrestre = terrestre;
    }
    
    /**
     * Obtiene un dato Tipoespecimen
     * 
     */
    public TipoEspecimen getTipoEspecimen(){
        return tipoEspecimen;
    }
    
    /**
     * Asigna un dato de tipoEspecimen 
     * @param tipoEspecimen 
     */
    public void setTipoEspecimen (TipoEspecimen tipoEspecimen){
        this.tipoEspecimen = tipoEspecimen;
    };
 
    /**
     * Metodo que devuelve una lista de estados
     * @return objeto list
     */
    public List<SelectItem> getItemsEstado() {
        if(itemsEstado == null){
            itemsEstado = new ArrayList< SelectItem >();
            itemsEstado.add( new SelectItem("","Todos") );
            itemsEstado.add( new SelectItem("Activo","Activo") );
            itemsEstado.add( new SelectItem("Revision","Revision") );
            itemsEstado.add( new SelectItem("Deshabilitado","Deshabilitado") );
        }
        return itemsEstado;
    }
    
    /**
     * Vevuelve una lista de donaciones
     * @return objeto list
     */
    public List<SelectItem> getItemsDonacion() {
        if(itemsDonacion == null){
            itemsDonacion = new ArrayList< SelectItem >();
            itemsDonacion.add( new SelectItem("","Todos") );
            itemsDonacion.add( new SelectItem("Si","Si") );
            itemsDonacion.add( new SelectItem("No","No") );
        }
        return itemsDonacion;
    }
    
    /**
     * Metodo que prepara la adicion de datos
     * @param event 
     */
    @Override
    public void prepararAdicion( ActionEvent event  ){
        acuatico = new Acuatico();
        entidad = new Especimen();
        terrestre = new Terrestre();
    }
    
    /**
     * Metodo que prepara la modificacion de los datos
     * @param especimen 
     */
    @Override
    public void prepararModificacion(Especimen especimen ){
        this.entidad = especimen;
        if( especimen.getTipoespecimen() == 'A'  ) {
            tipoEspecimen = TipoEspecimen.ACUATICO;
            setAcuatico(castAcuatico(especimen));
        }
        else if( especimen.getTipoespecimen() == 'T' ) {
            tipoEspecimen = TipoEspecimen.TERRESTRE;
            setTerrestre(castTerrestre(especimen));
        }
    }
    
    /**
     * Metodo que permite agregar una nueva entidad
     * @param event 
     */
    @Override
    public void agregarEntidad( ActionEvent event ){
        
        EspecimenDao especimenDao = FabricaDAO.crearEspecimenDao();
        
        boolean revisador = sesionBean.verificarPermiso("revisar", "especimen");
        
        if (tipoEspecimen == TipoEspecimen.TERRESTRE &&
                terrestre != null ){   
        System.out.print("terrestre");    
            terrestre.setCodigoespecimen(entidad.getCodigoespecimen());
            terrestre.setAnimal(entidad.getAnimal());
            terrestre.setRecoleccion(entidad.getRecoleccion());
            terrestre.setTipoespecimen(entidad.getTipoespecimen());
            terrestre.setNumeromuestras(entidad.getNumeromuestras());
            terrestre.setTipoconservacion(entidad.getTipoconservacion());
            terrestre.setTiposustrato(entidad.getTiposustrato());
            terrestre.setTextura(entidad.getTextura());
            terrestre.setColoracion(entidad.getColoracion());
            terrestre.setLongitud(entidad.getLongitud());
            terrestre.setDiametro(entidad.getDiametro());
            terrestre.setAltura(entidad.getAltura());
            terrestre.setPeso(entidad.getPeso());
            terrestre.setSexo(entidad.getSexo());
            terrestre.setMadurez(entidad.getMadurez());
            terrestre.setDetermino(entidad.getDetermino());
            terrestre.setConfirmo(entidad.getConfirmo());
            terrestre.setHabitat(entidad.getHabitat());
            terrestre.setEstatuslocal(entidad.getEstatuslocal());
            terrestre.setEstadomuestra(entidad.getEstadomuestra());
            terrestre.setDescripciontaxonomica(entidad.getDescripciontaxonomica());
            terrestre.setObservaciones(entidad.getObservaciones());
            terrestre.setUbicacionalmacen(entidad.getUbicacionalmacen());
            terrestre.setEstado( revisador ? "Activo" : "Revision" );
            terrestre.setDonacion(entidad.isDonacion());
            terrestre.setFotografia("");
            if (cargafoto == 'S'){
                    destino = entidad.getCodigoespecimen() +".jpg";
                    terrestre.setFotografia(destino);
                    terrestre.setFotografia(terrestre.getFotografia()+ ';');
                    System.out.print(terrestre.getFotografia());
                    
                    destino = "C:\\Sizoo\\fotos\\"+ destino;
                    try{
                        transferencia(getFile().getInputstream());
                        }catch (IOException e){
                            System.out.println(e.getMessage());
                        }
                    
                if(contador > 1){
                    for(int i =1; i<=contador-1; i++){
                          destino = terrestre.getCodigoespecimen() + i+ ".jpg";
                          terrestre.setFotografia(terrestre.getFotografia() + destino + ';');
                          destino = "C:\\Sizoo\\fotos\\"+ destino ;
                          try{
                            transferencia(fotos[i].getInputstream());
                            }catch (IOException e){
                                System.out.println(e.getMessage());
                        }
                    }
                    
                }
                
             }
            else {
                  for(int i =1; i<=1; i++){
                          destino =  "mariposa.jpg";
                          terrestre.setFotografia(destino + ';');
                          destino = "C:\\Sizoo\\fotos\\" + destino ;
//                          try{
//                            transferencia(fotos[i].getInputstream());
//                            }catch (IOException e){
//                                System.out.println(e.getMessage());
//                        }
                    }
            }
            TerrestreDao terrestreDao = FabricaDAO.crearTerrestreDao();
            terrestreDao.guardar(terrestre);
             // para los acuaticos es la misma?
        }
        else if (tipoEspecimen == TipoEspecimen.ACUATICO &&
            acuatico != null ) {
            acuatico.setCodigoespecimen(entidad.getCodigoespecimen());
            acuatico.setAnimal(entidad.getAnimal());
            acuatico.setRecoleccion(entidad.getRecoleccion());
            acuatico.setTipoespecimen(entidad.getTipoespecimen());
            acuatico.setNumeromuestras(entidad.getNumeromuestras());
            acuatico.setTipoconservacion(entidad.getTipoconservacion());
            acuatico.setTextura(entidad.getTextura());
            acuatico.setTiposustrato(entidad.getTiposustrato());
            acuatico.setColoracion(entidad.getColoracion());
            acuatico.setLongitud(entidad.getLongitud());
            acuatico.setDiametro(entidad.getDiametro());
            acuatico.setAltura(entidad.getAltura());
            acuatico.setPeso(entidad.getPeso());
            acuatico.setSexo(entidad.getSexo());
            acuatico.setMadurez(entidad.getMadurez());
            acuatico.setDetermino(entidad.getDetermino());
            acuatico.setConfirmo(entidad.getConfirmo());
            acuatico.setHabitat(entidad.getHabitat());
            acuatico.setEstatuslocal(entidad.getEstatuslocal());
            acuatico.setEstadomuestra(entidad.getEstadomuestra());
            acuatico.setDescripciontaxonomica(entidad.getDescripciontaxonomica());
            acuatico.setObservaciones(entidad.getObservaciones());
            acuatico.setUbicacionalmacen(entidad.getUbicacionalmacen());
            acuatico.setEstado( revisador ? "Activo" : "Revision" );
            acuatico.setFotografia("");
           if (cargafoto == 'S'){
                    destino = acuatico.getCodigoespecimen() +".jpg";
                    acuatico.setFotografia(destino);
                    acuatico.setFotografia(acuatico.getFotografia()  + ';');
                    destino = "C:\\Sizoo\\fotos\\"+ destino;
                    try{
                        transferencia(getFile().getInputstream());
                        }catch (IOException e){
                            System.out.println(e.getMessage());
                        }
                if(contador > 1){
                    for(int i =1; i<=contador-1; i++){
                          destino = acuatico.getCodigoespecimen() + i+ ".jpg";
                          acuatico.setFotografia(acuatico.getFotografia() + destino + ';');
                          destino = "C:\\Sizoo\\fotos\\"+ destino;
                          try{
                            transferencia(fotos[i].getInputstream());
                            }catch (IOException e){
                                System.out.println(e.getMessage());
                        }
                    }
                }
             }
           else {
               System.out.println("probando si entro");
                  for(int i =1; i<=1; i++){
                          destino =  "mariposa.jpg";
                          acuatico.setFotografia(destino + ';');
                          destino = "C:\\Sizoo\\fotos\\" + destino ;
                          System.out.println(acuatico.getFotografia());
//                          try{
//                            transferencia(fotos[i].getInputstream());
//                            }catch (IOException e){
//                                System.out.println(e.getMessage());
//                        }
                    }
            }
             //probalo asi!!! :V que rapido corre en tu maquina
            AcuaticoDao acuaticoDao = FabricaDAO.crearAcuaticoDao();
            acuaticoDao.guardar(acuatico);
            }
        recrearModelo();
    }
    
    /**
     * Metodo que obtiene la ruta de una fotografia
     * @param especimen
     * @return foto de tipo String
     */
    public String getFotograf(Especimen especimen){
        String [] fotografias = StringUtils.split(especimen.getFotografia(),";");
        String foto = fotografias.length > 0 ? fotografias[0] : null;
        return foto;
    }
    
    /**
     * Metodo que actualiza la entidad
     * @param event 
     */
    @Override
    public void actualizarEntidad( ActionEvent event ){   
        if (tipoEspecimen == TipoEspecimen.TERRESTRE &&
                terrestre != null ){   
            terrestre.setCodigoespecimen(entidad.getCodigoespecimen());
            terrestre.setAnimal(entidad.getAnimal());
            terrestre.setRecoleccion(entidad.getRecoleccion());
            terrestre.setTipoespecimen(entidad.getTipoespecimen());
            terrestre.setNumeromuestras(entidad.getNumeromuestras());
            terrestre.setTipoconservacion(entidad.getTipoconservacion());
            terrestre.setTextura(entidad.getTextura());
            terrestre.setColoracion(entidad.getColoracion());
            terrestre.setLongitud(entidad.getLongitud());
            terrestre.setDiametro(entidad.getDiametro());
            terrestre.setAltura(entidad.getAltura());
            terrestre.setPeso(entidad.getPeso());
            terrestre.setSexo(entidad.getSexo());
            terrestre.setMadurez(entidad.getMadurez());
            terrestre.setDetermino(entidad.getDetermino());
            terrestre.setConfirmo(entidad.getConfirmo());
            terrestre.setHabitat(entidad.getHabitat());
            terrestre.setEstatuslocal(entidad.getEstatuslocal());
            terrestre.setEstadomuestra(entidad.getEstadomuestra());
            terrestre.setDescripciontaxonomica(entidad.getDescripciontaxonomica());
            terrestre.setObservaciones(entidad.getObservaciones());
            terrestre.setUbicacionalmacen(entidad.getUbicacionalmacen());
            terrestre.setEstado("Activo");
            terrestre.setDonacion(entidad.isDonacion());
           TerrestreDao terrestreDao = FabricaDAO.crearTerrestreDao();
                      if (cargafoto == 'S'){
                    destino = terrestre.getCodigoespecimen() +".jpg;";
                    terrestre.setFotografia(destino);
                    terrestre.setFotografia(terrestre.getFotografia()  + ';');
                    destino = "C:\\Sizoo\\fotos\\"+ destino;
                    try{
                        transferencia(getFile().getInputstream());
                        }catch (IOException e){
                            System.out.println(e.getMessage());
                        }
                if(contador > 1){
                    for(int i =1; i<=contador-1; i++){
                          destino = terrestre.getCodigoespecimen() + i+ ".jpg";
                          terrestre.setFotografia(terrestre.getFotografia() + destino + ';');
                          destino = "C:\\Sizoo\\fotos\\"+ destino ;
                          try{
                            transferencia(fotos[i].getInputstream());
                            }catch (IOException e){
                                System.out.println(e.getMessage());
                        }
                    }
              
                }
             }
             terrestreDao.actualizar(terrestre);
        }
        else if (tipoEspecimen == TipoEspecimen.ACUATICO &&
            acuatico != null ) {
            acuatico.setCodigoespecimen(entidad.getCodigoespecimen());
            acuatico.setAnimal(entidad.getAnimal());
            acuatico.setRecoleccion(entidad.getRecoleccion());
            acuatico.setTipoespecimen(entidad.getTipoespecimen());
            acuatico.setNumeromuestras(entidad.getNumeromuestras());
            acuatico.setTipoconservacion(entidad.getTipoconservacion());
            acuatico.setTextura(entidad.getTextura());
            acuatico.setColoracion(entidad.getColoracion());
            acuatico.setLongitud(entidad.getLongitud());
            acuatico.setDiametro(entidad.getDiametro());
            acuatico.setAltura(entidad.getAltura());
            acuatico.setPeso(entidad.getPeso());
            acuatico.setSexo(entidad.getSexo());
            acuatico.setMadurez(entidad.getMadurez());
            acuatico.setDetermino(entidad.getDetermino());
            acuatico.setConfirmo(entidad.getConfirmo());
            acuatico.setHabitat(entidad.getHabitat());
            acuatico.setEstatuslocal(entidad.getEstatuslocal());
            acuatico.setEstadomuestra(entidad.getEstadomuestra());
            acuatico.setDescripciontaxonomica(entidad.getDescripciontaxonomica());
            acuatico.setObservaciones(entidad.getObservaciones());
            acuatico.setUbicacionalmacen(entidad.getUbicacionalmacen());
            acuatico.setEstado("Activo");
            AcuaticoDao acuaticoDao = FabricaDAO.crearAcuaticoDao();
           if (cargafoto == 'S'){
                    destino = acuatico.getCodigoespecimen() +".jpg;";
                    acuatico.setFotografia(destino);
                    acuatico.setFotografia(acuatico.getFotografia() + ';');
                    destino = "C:\\Sizoo\\fotos\\"+ destino ;
                    try{
                        transferencia(getFile().getInputstream());
                        }catch (IOException e){
                            System.out.println(e.getMessage());
                        }
                if(contador > 1){
                    for(int i =1; i<=contador-1; i++){
                          destino = acuatico.getCodigoespecimen() + i+ ".jpg";
                          acuatico.setFotografia(acuatico.getFotografia() + destino  + ";");
                          destino = "C:\\Sizoo\\fotos\\"+ destino;
                          try{
                            transferencia(fotos[i].getInputstream());
                            }catch (IOException e){
                                System.out.println(e.getMessage());
                        }
                    }
                }
             }
             acuaticoDao.actualizar(acuatico);
            }
        recrearModelo();
    }
    
    /**
     * Metodo que actualiza el tipo de especimen
     * @param event 
     */
    public void actualizarTipoEspecimen( AjaxBehaviorEvent event ) {
        if( entidad.getTipoespecimen() == 'A' ) {
            tipoEspecimen = TipoEspecimen.ACUATICO;
        }
        else if( entidad.getTipoespecimen() == 'T' ) {
            tipoEspecimen = TipoEspecimen.TERRESTRE;
        }
    }
    
    /**
     * Metodo que verifica que la información se encuentre validada
     * @param event
     *  
     */
    public String procesarFlujoAdicion( FlowEvent event ) {  
        return event.getNewStep();
    } 
    
    /**
     * Metodo que elimina una entidad
     * @param event 
     */
    @Override
    public void eliminarEntidad(  ActionEvent event ){
       if( !validarDependencia() ) {
           return;
       }
       
        EspecimenDao especimenDao = FabricaDAO.crearEspecimenDao();
        entidad.setEstado("Deshabilitado");
        especimenDao.actualizar( entidad );
        recrearModelo();
    }
        
    /**
     * Metodo que obtiene una lista de especies
     * @return objeto list
     */
    public List< SelectItem > getItemsEspecie() {
        if( itemsEspecimen == null ) {
            itemsEspecimen = new ArrayList< SelectItem >();
            EspecimenDao especimenDao = FabricaDAO.crearEspecimenDao();
            for( Especimen especimen : especimenDao.buscarTodos() ) {
                SelectItem item = new SelectItem( especimen, especimen.getCodigoespecimen());
                
                itemsEspecimen.add( item );
            }
        }
        return itemsEspecimen;
    }
    
    /**
     * Metodo que devuelve una lista de animales
     * @return objeto list
     */
     public List< SelectItem > getListaAnimal() {
        if( listaAnimal == null ) {
            listaAnimal = new ArrayList< SelectItem >();
            AnimalDao animalDao = FabricaDAO.crearAnimalDao();
            for( Animal animal : animalDao.buscarTodos() ) {
                Animal a = animalDao.removerProxy(animal);
                SelectItem item = new SelectItem( a, a.getNombrecientifico() );
                listaAnimal.add( item );
            }
        }
        return listaAnimal;
    }
     
     /**
      * Metodo que devuelve una lista de recolecciones
      * @return objeto list
      */
    public List< SelectItem > getListaRecoleccion() {
        
        java.text.SimpleDateFormat fecha=new java.text.SimpleDateFormat("dd/MM/yyyy");
        
        if( listaRecoleccion == null ) {
            listaRecoleccion = new ArrayList< SelectItem >();
            RecoleccionDao recoleccionDao = FabricaDAO.crearRecoleccionDao();
            for( Recoleccion recoleccion : recoleccionDao.buscarTodos() ) {
                Recoleccion r = recoleccionDao.removerProxy(recoleccion);
                String etiqueta = "";
                if( r instanceof Nacional ) {
                    etiqueta = ((Nacional)r).getZona().getMunicipio().getNombre() + ", ";
                    etiqueta += ((Nacional)r).getZona().getMunicipio().getDepartamento().getNombre() + ", ";
                }
                else if( r instanceof Internacional ) {
                    etiqueta = ((Internacional)r).getPais() + ", ";
                    etiqueta += ((Internacional)r).getDonante() + ", ";
                }
                etiqueta += fecha.format(r.getFecharecoleccion());
                SelectItem item = new SelectItem( r, etiqueta);
                listaRecoleccion.add( item );
            }
        }
        return listaRecoleccion;
    }

    /**
     * Convierte un tipo acuatico a especimen
     * @param especimen
     *  
     */
    public Acuatico castAcuatico(Especimen especimen) {
        return (Acuatico)especimen;
    }
    
    /**
     * Convierte un tipo terrestre a especimen
     * @param especimen
     *  
     */
    public Terrestre castTerrestre(Especimen especimen) {
        return (Terrestre)especimen;
    }
    
    /**
     * Obtiene un dato de tipo archivo
     *  
     */
    public UploadedFile getFile() {  
        return file;  
    }  
  
    /**
     * Selecciona un dato de tipo archivo
     * @param file 
     */
    public void setFile(UploadedFile file) {  
        this.file = file;  
    } 
    
    /**
     * Guarda un archivo
     * @param event 
     */
    public void handleFileUpload(FileUploadEvent event) {  
        FacesMessage msg = new FacesMessage("Succesful", event.getFile().getFileName() + " is uploaded.");  
        FacesContext.getCurrentInstance().addMessage(null, msg); 
        setFile(event.getFile());
        contador++;
        fotos[contador] = getFile();
        setCargafoto('S');
        System.out.print(getContador());
        
    } 
    
    //WAKA WAKA WAKA WAKA    :v . . . . . .
    
     /**
      * Metodo encargado de transferrir la fotografia
      * @param in 
      */
    public void transferencia(InputStream in){
        System.out.println("probando si entro 34");
        try {
            OutputStream out =  new FileOutputStream(new File (destino));
            int reader=0;
            byte[] bytes = new byte[(int)fotos[1].getSize()];
            while((reader = in.read(bytes)) != -1) {
                out.write(bytes, 0 , reader);
            }
            in.close();
            out.flush();
            out.close();
        }catch (IOException e){
           System.out.println(e.getMessage());
        }
        //No entor al metodo que carga la fotoo por eos falla
    }

    /**
     * Obtiene la fotografia
     * @return 
     */
    public char getCargafoto() {
        return cargafoto;
    }
    
    /**
     * Selecciona la fotografia
     * @param cargafoto 
     */
    public void setCargafoto(char cargafoto) {
        this.cargafoto = cargafoto;
    }
    
    public int getContador() {
        return contador;
    }
    
    public void setContador(int contador) {
        this.contador = contador;
    }
    
    /**
     * Metodo que devuelve una lista de habitats
     * @return objeto list
     */
    public List<SelectItem> getListaHabitats() {
        if( listaHabitats == null ) {
            listaHabitats = new ArrayList<SelectItem>();
            EspecimenDao especimenDao = FabricaDAO.crearEspecimenDao();
            for( String habitat : especimenDao.buscarHabitats() ) {
                SelectItem item = new SelectItem( habitat, habitat );
                listaHabitats.add( item );
            }
        }
        
        return listaHabitats;
    }

    /**
     * Instancia un nuevo EspecimenDao
     * 
     */
    @Override
    protected EspecimenDao getDAO () {
        return FabricaDAO.crearEspecimenDao();
    }

    /**
     * 
     * @param transaccion indica que transaccion se debera realizar 
     * @return objeto de tipo boolean que indica que tipo de transaccion se realizara
     */
    @Override
    protected boolean debeValidar (Transaccion transaccion) {
        boolean validacion = false;
        
        switch( transaccion ) {
            case INSERCION:
            case ELIMINACION:
                validacion = true;
        }
        
        return validacion;
    }
}
